package hotel.meituan.oversea.biz.task;

import com.alibaba.fastjson.JSON;
import hotel.base.oversea.constant.CallbackConstants;
import hotel.base.oversea.constant.CommonConstants;
import hotel.base.oversea.constant.CommonUrlConstants;
import hotel.base.oversea.constant.MeituanConstants;
import hotel.base.oversea.constant.enums.MessageEnums;
import hotel.base.oversea.constant.enums.MtGoodsEnums;
import hotel.base.oversea.utils.DateUtil;
import hotel.base.oversea.utils.Result;
import hotel.base.oversea.utils.SendUtils;
import hotel.base.oversea.utils.StringUtil;
import hotel.base.oversea.vo.BatchPushRoomDatasVo;
import hotel.base.oversea.vo.RoomDataEntityVO;
import hotel.base.oversea.vo.RoomPriceVo;
import hotel.base.oversea.vo.meituan.response.order.MtHotelOrderCheckPricesVo;
import hotel.base.oversea.vo.meituan.response.order.MtHotelOrderCheckVo;
import hotel.meituan.oversea.api.entity.MtHotelGoodsPriceChangeLog;
import hotel.meituan.oversea.api.entity.MtHotelGoodsStatusChangeLog;
import hotel.meituan.oversea.api.entity.MtNotifyShortLog;
import hotel.meituan.oversea.api.vo.switchs.ModifyRemainVo;
import hotel.meituan.oversea.biz.config.service.RedisService;
import hotel.meituan.oversea.biz.mapper.MtHotelGoodsPriceChangeLogMapper;
import hotel.meituan.oversea.biz.mapper.MtHotelGoodsStatusChangeLogMapper;
import hotel.meituan.oversea.biz.mapper.MtNotifyShortLogMapper;
import hotel.meituan.oversea.biz.utils.RestTemplateUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;
import org.springframework.util.ObjectUtils;
import org.springframework.web.client.RestTemplate;

import java.math.BigDecimal;
import java.util.*;


@Slf4j
@Component
public class MeituanJobBookingUpdateGoodsSwInventoryTask {
    private String timestamp = "Mjbugsit"+String.valueOf(System.currentTimeMillis());
    @Autowired
    private RestTemplate restTemplate;
    @Autowired
    private RedisTemplate redisTemplate;
    @Autowired
    private RedisService redisService;
    @Autowired
    private MtNotifyShortLogMapper mtNotifyShortLogMapper;
    @Autowired
    private MtHotelGoodsPriceChangeLogMapper mtHotelGoodsPriceChangeLogMapper;

    @Autowired
    private MtHotelGoodsStatusChangeLogMapper mtHotelGoodsStatusChangeLogMapper;

    private void setTimestamp(String timestamp){
        this.timestamp = timestamp;
    }

    public static void main(String[] args) {
        Map<String,String> changeMap = new HashMap<>();
        changeMap.put("变化前 2020-09-08 "+1111,"变化后 2020-09-08 "+222);
        changeMap.put("变化前 2020-09-09 "+4444,"变化后 2020-09-09 "+333);
        System.out.printf(""+ JSON.toJSONString(changeMap));
    }

    //@Async 标识这个方法异步执行，可返回void或Future

    /**
     * {"code":6,"desc":"库存不足","priceModels":[],"remainRoomNum":0}
     * {"code":3,"desc":"产品goodsId:17387288不可预订, goodsStatus:0","priceModels":[]}
     *
     *{"code":0,"priceModels":[{"date":"2020-10-02","dayType":0,"salePrice":75600,"subPrice":3780,"subRatio":500}],"remainRoomNum":999}
     *
     *
     *
     * @param swOrderId
     * @param switchsHotelId
     * @param roomId
     * @param checkinDate
     * @param checkoutDate
     * @param checkVoRemainRoomNum
     * @param mtHotelOrderCheckVo
     * @param mtHotelId
     * @param mtGoodsId
     */
    @Async
    public void executeUpdateInventory(String swOrderId, String switchsHotelId, String roomId, String checkinDate, String checkoutDate, Integer checkVoRemainRoomNum, MtHotelOrderCheckVo mtHotelOrderCheckVo,String mtHotelId,Integer mtGoodsId){
        //  swOrderId  可能为文字  MeituanJobBookingUpdateAllSaleGoodsByOneHotelTask  调用该方法
        log.info("MeituanJobBookingUpdateGoodsSwInventoryTask {} >>>>>>>>> 异步线程 下单更新产品携程库存  开始执行时间：{},swOrderId={}",timestamp,DateUtil.getNowTime(),swOrderId);

        if(mtHotelOrderCheckVo.getCode()==3){// || mtHotelOrderCheckVo.getCode()==6      6 库存不足  可能为连住单所有不能直接推送房态不可预定 或单住但是购买多间房
            //3 房态为不可预订   6 库存不足
            checkVoRemainRoomNum = 0;
        }

        //version qyy  调用美团的预下单效验更改，如果返回999设置为10，返回1-5就根据返回的具体数量传过来
        if(!ObjectUtils.isEmpty(checkVoRemainRoomNum)){
            //库存数量 如果返回999 库存设置为10 返回1-5设置为5,返回0为0
            int num;
            if (checkVoRemainRoomNum == 999) {
                num = 5;
            }else{
                num = checkVoRemainRoomNum;
            } /*else if (1 <= checkVoRemainRoomNum && checkVoRemainRoomNum <= 5) {
                num = 5;
            } else {
                num = 0;
            }*/
            //请求参数
            ModifyRemainVo modifyRemainVo = new ModifyRemainVo();
            modifyRemainVo.setHotelId(Integer.valueOf(switchsHotelId));
            modifyRemainVo.setRoomId(Integer.valueOf(roomId));
            modifyRemainVo.setNum(num);
            modifyRemainVo.setTime(checkinDate);
            modifyRemainVo.setEndTime(checkoutDate);

            if(swOrderId.contains("轮询")){//MeituanJobBookingUpdateAllSaleGoodsByOneHotelTask  调用该方法
                if(num != 5){
                    log.info("MeituanJobBookingUpdateGoodsSwInventoryTask {} >>>>>>>>> 异步线程 新订单酒店轮询产品 修改库存  switchModifyRemain 请求参数： {}", JSON.toJSONString(modifyRemainVo));
                    Result<Object> result = RestTemplateUtils.post(CommonUrlConstants.SWITCHS_HOST+"/switchCreateRoom/modifyRemain", JSON.toJSONString(modifyRemainVo),restTemplate);
                    log.info("MeituanJobBookingUpdateGoodsSwInventoryTask {} >>>>>>>>> 异步线程 新订单酒店轮询产品 修改库存  result返回： {}", JSON.toJSONString(result));
                    if(result.getCode()!= CommonConstants.SUCCESS){
                        SendUtils.dingMsg("[JOBMT-GOODS-CHANGE] 新订单酒店轮询产品,推送携程失败！ ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送内容："+ JSON.toJSONString(modifyRemainVo)+" 响应内容："+ JSON.toJSONString(result), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                    }else{
                        if(mtHotelOrderCheckVo.getCode()==3){
                            SendUtils.dingMsg("[JOBMT-ROOM-STATE] 新订单酒店轮询产品'房态'不可预订,推送携程库存为0 ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送内容："+ JSON.toJSONString(modifyRemainVo), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);

                            //价格改变 更新美团产品相关表数据：增加产品房态变动日志
                            MtHotelGoodsStatusChangeLog mtHotelGoodsStatusChangeLog = new MtHotelGoodsStatusChangeLog();
                            mtHotelGoodsStatusChangeLog.setId(StringUtil.getUUID());
                            mtHotelGoodsStatusChangeLog.setMtHotelId(mtHotelId);
                            mtHotelGoodsStatusChangeLog.setMtGoodsId(String.valueOf(mtGoodsId));
                            mtHotelGoodsStatusChangeLog.setMtDate(checkinDate);
                            mtHotelGoodsStatusChangeLog.setStatus(2);
                            mtHotelGoodsStatusChangeLog.setType("4");//1  rp接口  2、房态实时接口   3  价格日历接口  4 新订单校验
                            mtHotelGoodsStatusChangeLog.setCreateTime(new Date());
                            try {
                                mtHotelGoodsStatusChangeLogMapper.insert(mtHotelGoodsStatusChangeLog);
                            }catch (Exception e){
                                e.printStackTrace();
                            }

                            redisService.remove(CallbackConstants.REDIS_KEY_CALLBACK_CHANGE_STATUS_HEAD+mtHotelId+"_"+mtGoodsId+"_"+checkinDate);


                        }else{
                            SendUtils.dingMsg("[JOBMT-REMAIN-NOT999] 新订单酒店轮询产品库存变化,推送携程 ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送内容："+ JSON.toJSONString(modifyRemainVo), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                        }
                    }
                    log.info("MeituanJobBookingUpdateGoodsSwInventoryTask {} >>>>>>>>> 异步线程 新订单酒店轮询产品 修改库存  switchModifyRemain 响应参数： {}", JSON.toJSONString(result));

                }
            }else{
                try {
                    //下了新订单，即有库存变化，不管是不是999 ，都要推送携程--->>只是钉钉消息的话 999库存充足的不提示，小于10的要提示
                    log.info("MeituanJobBookingUpdateGoodsSwInventoryTask >>>>>>>>> 异步线程 下单更新产品携程库存 修改库存  switchModifyRemain 请求参数： {}", JSON.toJSONString(modifyRemainVo));
                    Result<Object> result = RestTemplateUtils.post(CommonUrlConstants.SWITCHS_HOST+"/switchCreateRoom/modifyRemain", JSON.toJSONString(modifyRemainVo),restTemplate);
                    if(result.getCode()!= CommonConstants.SUCCESS){
                        SendUtils.dingMsg("[JOBMT-GOODS-ERROR] 新订单产品变化,推送携程失败！ ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送携程内容："+ JSON.toJSONString(modifyRemainVo)+" 响应内容："+ JSON.toJSONString(result)+" 订单号："+swOrderId, MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                    }else{
                        if(num != 5){//每次新订单都要推送携程库存，，库存充足则推送的不再发钉钉消息
                            if(mtHotelOrderCheckVo.getCode()==3){
                                SendUtils.dingMsg("[JOBMT-ROOM-STATE] 新订单产品'房态'不可预订,推送携程库存为0 ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送内容："+ JSON.toJSONString(modifyRemainVo)+" 订单号："+swOrderId, MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                                //价格改变 更新美团产品相关表数据：增加产品房态变动日志
                                MtHotelGoodsStatusChangeLog mtHotelGoodsStatusChangeLog = new MtHotelGoodsStatusChangeLog();
                                mtHotelGoodsStatusChangeLog.setId(StringUtil.getUUID());
                                mtHotelGoodsStatusChangeLog.setMtHotelId(mtHotelId);
                                mtHotelGoodsStatusChangeLog.setMtGoodsId(String.valueOf(mtGoodsId));
                                mtHotelGoodsStatusChangeLog.setMtDate(checkinDate);
                                mtHotelGoodsStatusChangeLog.setStatus(2);
                                mtHotelGoodsStatusChangeLog.setRemark("redis="+redisService.get(CallbackConstants.REDIS_KEY_CALLBACK_CHANGE_STATUS_HEAD+mtHotelId+"_"+mtGoodsId+"_"+checkinDate));
                                mtHotelGoodsStatusChangeLog.setType("4");//1  rp接口  2、房态实时接口   3  价格日历接口  4 新订单校验
                                mtHotelGoodsStatusChangeLog.setCreateTime(new Date());
                                try {
                                    mtHotelGoodsStatusChangeLogMapper.insert(mtHotelGoodsStatusChangeLog);
                                }catch (Exception e){
                                    e.printStackTrace();
                                }
                                redisService.remove(CallbackConstants.REDIS_KEY_CALLBACK_CHANGE_STATUS_HEAD+mtHotelId+"_"+mtGoodsId+"_"+checkinDate);
                            }else{
                                SendUtils.dingMsg("[JOBMT-REMAIN-NOT999] 新订单产品库存变化,推送携程 ",DateUtil.getCurrTime()+" 美团返回："+ JSON.toJSONString(mtHotelOrderCheckVo)+" 推送内容："+ JSON.toJSONString(modifyRemainVo)+" 订单号："+swOrderId, MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                            }
                        }
                    }
                    log.info("MeituanJobBookingUpdateGoodsSwInventoryTask >>>>>>>>> 异步线程 下单更新产品携程库存 修改库存  switchModifyRemain 响应参数： {}", JSON.toJSONString(result));
                }catch (Exception e){
                    e.printStackTrace();
                }
            }

        }

        //对比美团很好办系统存在价格，判断是否发送变化，有则更新加入缓存队列
        List<MtHotelOrderCheckPricesVo> priceModels =  mtHotelOrderCheckVo.getPriceModels();
        log.info("下单更新产品携程库存priceModels={}", JSON.toJSONString(priceModels));
        if(null != priceModels && priceModels.size()==1){//20200918 qyy   增加判断priceModels.size()==1--》美团连住的价格是错误的 他们系统问题  不可推给价格给携程，，，其他接口如价格日历接口返回的价格都是单住价格

            List<RoomDataEntityVO> oneHotelAboutAllChangeGoodsVoSwitchsApi = new ArrayList<>();

            RoomDataEntityVO oneChangeGoodsSwitchsApi = new RoomDataEntityVO();
            oneChangeGoodsSwitchsApi.setGoodId(mtGoodsId);//当前产品id
            oneChangeGoodsSwitchsApi.setRoomStatusInventorys(null);//当前产品所有多组房态日期集合--》当前为价格异步推送方法，该参数设置null
            oneChangeGoodsSwitchsApi.setGoodInventory(1);

            Map<String,String> changeMap = new HashMap<>();
            List<RoomPriceVo> changeOneGoodsDatePriceListBuildSwitchsVo = new ArrayList<>();//重构携程接口对象，当前该产品的多组变化价格日期数据集合list
            for (MtHotelOrderCheckPricesVo mtHotelOrderCheckPricesVo:priceModels){
                String mtDate = mtHotelOrderCheckPricesVo.getDate();
                Integer newSalePrice = mtHotelOrderCheckPricesVo.getSalePrice();
                //2020-10-22 qyy 价格是否发生变化根据缓存做比较，不查询数据库，不准
                //2020-10-22 qyy MtHotelGoodsPrice oldPrice = mtHotelGoodsPriceService.queryGoodsByDate(mtHotelId,mtGoodsId,mtDate);
                Integer has = (Integer)redisTemplate.opsForValue().get(CallbackConstants.REDIS_KEY_CALLBACK_CHANGE_PRICE_HEAD+mtHotelId+"_"+mtGoodsId+"_"+mtDate);
                log.info("下单更新产品携程库存newSalePrice={},oldPrice={}", JSON.toJSONString(newSalePrice), JSON.toJSONString(has));
                if(null != has && BigDecimal.valueOf(has).compareTo(BigDecimal.valueOf(newSalePrice))<0){//上一次价格比当前价格小时
                    if(new BigDecimal(newSalePrice).compareTo(new BigDecimal(5000))<0){
                        log.info("新订单价格小于50，当前调整为50,goodsId={}，hotelId={}",mtGoodsId,mtHotelId);
                        newSalePrice = 5000;
                    }
                    Integer libraryPrice = (Integer) redisService.get(MeituanConstants.REDIS_ONE_GOODS_PRICE_LIBRARY_NEW+mtHotelId+"_"+mtGoodsId);
                    Boolean todo = true;

                    if(!ObjectUtils.isEmpty(libraryPrice) && BigDecimal.valueOf(libraryPrice).compareTo(BigDecimal.valueOf(newSalePrice))>0){
                        newSalePrice = libraryPrice;//标准价
                    }else{
                        Integer minPrice = 20000;//单位分
                        if(null != redisService.get("sw_price_check_change_min")){
                            minPrice =(Integer) redisService.get("sw_price_check_change_min");
                        }

                        Double pro = 0.6;
                        if(null != redisService.get(CommonConstants.PRICE_CHECK_CHANGE_MIN_PRO)){//40
                            pro =new BigDecimal((Integer) redisService.get("sw_price_check_change_min_pro")).multiply(new BigDecimal(0.01)).doubleValue();
                        }

                        if(new BigDecimal(newSalePrice).compareTo(new BigDecimal(minPrice))<=0 && new BigDecimal(has).multiply(new BigDecimal(pro)).compareTo(new BigDecimal(newSalePrice))>0){
                            log.info("新订单 价格可能异常最新价格="+newSalePrice+" 上一次价格="+has+" 产品信息："+mtHotelId+"_"+mtGoodsId+"_"+mtDate);
                            //维持上一次has价格，不做是否变化判断，不推送携程
                            todo = false;
                        }
                    }
                    if(todo){
                        //价格发生变化
                        log.info("订单校验到产品价格变化 mtHotelOrderCheckPricesVo={},priceModels={}", JSON.toJSONString(mtHotelOrderCheckPricesVo), JSON.toJSONString(priceModels));
                        RoomPriceVo thisGoodsThisOneDatePirceSwitchsVo = new RoomPriceVo();
                        thisGoodsThisOneDatePirceSwitchsVo.setSalePrice(newSalePrice);
                        thisGoodsThisOneDatePirceSwitchsVo.setDate(mtDate);
                        thisGoodsThisOneDatePirceSwitchsVo.setSubPrice(mtHotelOrderCheckPricesVo.getSubPrice());
                        changeOneGoodsDatePriceListBuildSwitchsVo.add(thisGoodsThisOneDatePirceSwitchsVo);
                        //更新库表价格
                    /*try{
                        mtHotelGoodsService.saveGetMtHotelGoodsPrice(Long.valueOf(mtGoodsId),mtDate,DateUtil.formatDate(DateUtil.addDay(mtDate,1),"yyyy-MM-dd"));
                    }catch (Exception e){
                        e.printStackTrace();
                    }*/
                        changeMap.put("变化前 "+mtDate+" "+has,"变化后 "+mtDate+" "+newSalePrice);
                        Long days = DateUtil.dateDiff(DateUtil.getCurrTime(),"day",mtDate,"yyyy-MM-dd");
                        //redisTemplate.opsForValue().set(redisKeyExpiDays,newSalePrice,Math.abs(days)+2, TimeUnit.DAYS);--->>> 不set缓存 让主动定时器再跑一下
                        //2、推给飞猪，接口直推（目前飞猪没有限制次数）
                    /*if(null == redisTemplate.opsForValue().get("push_fp_price_status_change_close")){
                        Result result = hotel.common.utils.RestTemplateUtils.post(CommonUrlConstants.FP_HOST+ FpConstants.API_URL_FP_CALLBACK_PRICE_STATUS, GsonUtils.GsonString(oneChangeGoodsSwitchsApi),restTemplate);
                        if(result.getCode() != CommonConstants.SUCCESS){
                            SendUtils.dingMsgNotLog("[MTSW-ORDER-STATUS] 新订单推送飞猪房态异常 ", hotel.common.utils.DateUtil.getCurrTime()+" 接口返回："+GsonUtils.GsonString(result), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                        }
                    }*/

                        //价格改变 更新美团产品相关表数据：增加产品价格变动日志 goods_price_change_log
                        MtHotelGoodsPriceChangeLog mtHotelGoodsPriceChangeLog = new MtHotelGoodsPriceChangeLog();
                        mtHotelGoodsPriceChangeLog.setId(StringUtil.getUUID());
                        mtHotelGoodsPriceChangeLog.setMtHotelId(mtHotelId);
                        mtHotelGoodsPriceChangeLog.setMtGoodsId(String.valueOf(mtGoodsId));
                        mtHotelGoodsPriceChangeLog.setMtDate(mtDate);
                        mtHotelGoodsPriceChangeLog.setMtSalePrice(newSalePrice);//最新价格
                        mtHotelGoodsPriceChangeLog.setCreateTime(new Date());
                        mtHotelGoodsPriceChangeLog.setSource(1);
                        mtHotelGoodsPriceChangeLog.setType("4");//1  rp接口  2、房态实时接口   3  价格日历接口  4 新订单校验
                        try {
                            mtHotelGoodsPriceChangeLogMapper.insert(mtHotelGoodsPriceChangeLog);//酒店id+产品id+日期+价格 一般是不会重复，因为有变动的价格才会插入表
                        }catch (Exception e){
                            e.printStackTrace();
                        }

                        redisService.remove(CallbackConstants.REDIS_KEY_CALLBACK_CHANGE_PRICE_HEAD+mtHotelId+"_"+mtGoodsId+"_"+mtDate);
                    }

                }

            }
            if(null != changeOneGoodsDatePriceListBuildSwitchsVo && changeOneGoodsDatePriceListBuildSwitchsVo.size()>0){
                oneChangeGoodsSwitchsApi.setRoomPrices(changeOneGoodsDatePriceListBuildSwitchsVo);//当前产品所有多组价格日期集合
                oneHotelAboutAllChangeGoodsVoSwitchsApi.add(oneChangeGoodsSwitchsApi);//追加入携程vo酒店所有变化产品集合中

                //当前为订单处理调用该方法，产品只会有一个

                String thisTimestamp = StringUtil.getUUID();
                BatchPushRoomDatasVo oneHotelVoSwitchsApi = new BatchPushRoomDatasVo();
                oneHotelVoSwitchsApi.setTimestamp(thisTimestamp);
                oneHotelVoSwitchsApi.setMtHotelId(Integer.valueOf(mtHotelId));//要推送的酒店一个
                oneHotelVoSwitchsApi.setRoomDataEntityList(oneHotelAboutAllChangeGoodsVoSwitchsApi);//要推送的该酒店的产品信息集合（一个vo 包含 产品id 产品默认库存1 产品日期价格集合 产品日期房态集合）
                //一个酒店变化的产品数据保存到缓存队列
                //String pushThisTimestamp = "push_price_"+thisTimestamp+"_"+StringUtil.getFourRandom()+mtHotelId;
                log.info("订单校验到产品价格变化 即时推送携程={},swOrderId={}", JSON.toJSONString(oneHotelVoSwitchsApi),swOrderId);
                if(swOrderId.contains("轮询")){
                    SendUtils.dingMsg("[JOBMT-GOODS-CHANGE] 新订单酒店轮询产品价格变化,队列推送携程 ",DateUtil.getCurrTime()+" 价格："+ JSON.toJSONString(changeMap)+" 推送内容："+ JSON.toJSONString(oneHotelVoSwitchsApi), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                }else{
                    SendUtils.dingMsg("[JOBMT-GOODS-CHANGE] 非连住新订单产品价格变化,队列推送携程 ",DateUtil.getCurrTime()+" 价格："+ JSON.toJSONString(changeMap)+" 推送内容："+ JSON.toJSONString(oneHotelVoSwitchsApi)+" 订单号："+swOrderId, MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                }
                redisTemplate.opsForList().leftPush(MeituanConstants.REDIS_CHANGE_GOODS_DATA_MANY_HOTEL, JSON.toJSONString(oneHotelVoSwitchsApi));//每次放进去的是属于一个酒店的产品数据，携程批量修改价格接口需要为同一个酒店的产品List
                //2、推给飞猪，接口直推（目前飞猪没有限制次数）
                /*if(null == redisTemplate.opsForValue().get("push_fp_price_status_change_close")){
                    Result result = hotel.base.oversea.utils.RestTemplateUtils.post(CommonUrlConstants.FP_HOST+ FpConstants.API_URL_FP_CALLBACK_PRICE_STATUS,GsonUtils.GsonString(oneChangeGoodsSwitchsApi),restTemplate);
                    if(result.getCode() != CommonConstants.SUCCESS){
                        SendUtils.dingMsgNotLog("[MTSW-ORDER-PRICE] 新订单推送飞猪'价格'异常 ", hotel.base.oversea.utils.DateUtil.getCurrTime()+" 接口返回："+GsonUtils.GsonString(result), MessageEnums.genre.GOODS_STATUS_AND_PRICE.getCode(),restTemplate);
                    }
                }*/

                MtNotifyShortLog mtNotifyShortLog = new MtNotifyShortLog();
                mtNotifyShortLog.setId(StringUtil.getUUID());
                mtNotifyShortLog.setTimestamp(thisTimestamp);
                mtNotifyShortLog.setCreateTime(new Date());
                mtNotifyShortLog.setMtHotelId(mtHotelId);
                mtNotifyShortLog.setSwHotelId(null);
                if(swOrderId.contains("轮询")){
                    mtNotifyShortLog.setRemark("新订单酒店轮询产品价格变化,即时推送携程数据保存日志");
                }else{
                    mtNotifyShortLog.setRemark("非连住新订单产品价格变化,即时推送携程数据保存日志");
                }
                mtNotifyShortLog.setOprate(MtGoodsEnums.goodsChangeType.PUSH.getCode());//push
                mtNotifyShortLog.setSource(MtGoodsEnums.goodsChangeSource.PULL_ORDER_PRICE.getCode());//10 异步价格  11 主动查询价格 20 异步房态  21 主动查询房态 30 携程推送成功数据
                try {
                    mtNotifyShortLogMapper.insert(mtNotifyShortLog);
                }catch (Exception e){
                    log.info("新订单产品价格变化,即时推送携程数据保存日志mtNotifyShortLog异常 mtNotifyShortLog={}", JSON.toJSONString(mtNotifyShortLog));
                    e.printStackTrace();
                }

            }


        }

        log.info("MeituanJobBookingUpdateGoodsSwInventoryTask {} >>>>>>>>> 异步线程 下单更新产品携程库存  执行结束时间：{}.swOrderId={}",timestamp,DateUtil.getNowTime(),swOrderId);

    }


}
